package com.qst.order.utils;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 通用JSON解析工具，支持解析正常JSON和双重编码JSON
 */
public class JsonUtils {
    private static final ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 自适应解析JSON字符串（支持正常JSON和双重编码JSON）
     * @param jsonStr 可能是正常JSON或双重编码JSON
     * @param typeReference 目标类型引用
     * @return 解析后的对象
     */
    public static <T> T parseJson(String jsonStr, TypeReference<T> typeReference) {
        if (jsonStr == null || jsonStr.trim().isEmpty()) {
            return null;
        }

        try {
            // 尝试1：按双重编码解析（先解外层字符串，再解内层JSON）
            String innerJson = objectMapper.readValue(jsonStr, String.class);
            return objectMapper.readValue(innerJson, typeReference);
        } catch (Exception e1) {
            try {
                // 尝试2：按正常JSON直接解析
                return objectMapper.readValue(jsonStr, typeReference);
            } catch (IOException e2) {
                // 两种解析都失败
                throw new RuntimeException("JSON解析失败: " + jsonStr, e2);
            }
        }
    }

    /**
     * 解析规格组合（返回空Map而不是抛异常，适合业务场景）
     */
    public static Map<String, String> parseSpecCombo(String jsonStr) {
        try {
            return parseJson(jsonStr, new TypeReference<Map<String, String>>() {});
        } catch (Exception e) {
            return new HashMap<>(); // 解析失败返回空Map
        }
    }

    /**
     * 解析规格选项（返回空Map而不是抛异常，适合业务场景）
     */
    public static Map<String, List<String>> parseSpecOptions(String jsonStr) {
        try {
            return parseJson(jsonStr, new TypeReference<Map<String, List<String>>>() {});
        } catch (Exception e) {
            return new HashMap<>(); // 解析失败返回空Map
        }
    }
}
